<simpleNode>

	<example>
		A node has a list of child nodes (used symmetricly)
		and multiple sets of floating point numbers (quantity depends on quantity of nodes).
		<question>Would it complicate things too much for each node to have 1 OR MORE list of child nodes?</question>
		Each set of floating point numbers has a hard-coded function mapping number index to node index.
		For example, a bayes number set maps 32 numbers to 5 nodes.
		Each number maps to 0-5 nodes (or all 5, and each being 1 or 0?).
		Another example: a neural node has 1 number for its electric charge, and that is a whole set.
		The other set is 1 number for each child node. A neural algorithm would use both sets of each node.
	</example>
	
	<mapNumberIndexToNodeIndexs>
		<example>7 nodes. 1 weight, for the parent node, shared by all childs.</example>
		<example>7 nodes. 7 weights, 1 to 1 pairing.</example>
		<example>7 nodes. 49 weights, for each pair with direction.</example>
		<example>7 nodes. 128 weights, for bayesian combinations.</example>
		<example>7 nodes. 3^7 weights, for 3-way bayesian-like combinations. May be too complex than its worth1.</example>
	</mapNumberIndexToNodeIndexs>
	
	<question>
		In a network with 1000 nodes, and 1 node has 20 childs, can that node be viewed as an optimization
		of 980 zeros and 20 ones? How would the unoptimized combined form represent a neural node firing?
		<example>
			Many of this node:
			<example>7 nodes. 7 weights, 1 to 1 pairing.</example>
			can be an optimization of this network:
			<example>7 nodes. 49 weights, for each pair with direction.</example>
		</example>
		<example>
			A neural node with 128 childs, and each child has 7 childs,
			can do the same as a bayesian node with those same 7 childs.
			But that restricts the algorithm of the nodes, like any other optimization does.
		</example>
	</question>
	
	Looking for a way to iterate a simple function (taking a constant number of floating points)
	over floating points of all floating-point-sets of a node?
	For example, to sum the bayesian weights when 1 specific child node is true.
	Other example, sum the bayesian weights whe 1 specific child is true and 1 other specific child is false?
	
	Maybe the floating-point-sets should choose how to iterate. Maybe they should have a function
	that takes another set as a parameter and does the iterating?
	Its squared more hard coding, but may work well enough to get the job done.
	
	Maybe a separate type of thing should be defined that takes 2 floating-point-sets as parameters
	and chooses an iteration order and size of it.
	For example, an iterater generater that iterates over a bayes set and a neural set,
	and for example if there are 7 nodes and the bayes set is size 128 and the neural set is size 7,
	the iterater size is 7*128? Another example would be size 2*7*128. Another example would be size 128?
	2*7*128 makes the most sense, even though the last 7 can probably be calculated from the first 7.
	Maybe 3 sets, 7 7 and 128, make more sense than 2 sets, 14 and 128.
	All 2 or 3 sets must change size at the same time.
	
	<sortingIterater>
		Maybe one of these iterater generators should use sorted order, but that may be outside the scope of what I designed it for,
		and sorting the whole network each cycle of the network is too slow. It has to stay sorted to be efficient.
	</sortingIterater>
	
	An iterater combining 2 sets of N and N^2 numbers, may be size N^2 or N^3.
	
	An iterator combining 2 sets of N numbers, may be size N or 2*N or 5*N or N^2. Size N is useful, but are the others useful?
	
	An iterator combining 5 sets of 1 number and 1 set of Y numbers, may be size Y, and each iteration uses 6 numbers.
	
	You can have a sequence of sets, but everything in a set must be used as unordered (even if the set is stored as a list).
	
	Every set must be able to change size (and require other sets change size simultaneously).
	Every sequence is fixed size.
	
	A node has a set of nodes and multiple sets of numbers.
	
	Simple operations on node count: multiply (for neural) and power (for bayesian).
	
	N = how many child nodes of a node?
	C is an arbitrary constant.
	
	N^C
		N^0 = 1
		N^1 = N, and is neural size, or array
		N^2 is unoptimized neural network
	C^N
		0^N = 0
		1^N = 1
		2^N is bayesian size
		
	Can avoid creating java class for [N^C1 * C2^N] if allow combining these iterater generators.
	
	N^negInfinity = 0 = 0^N
	N^0 = 1 = 1^N
	
	Practical sizes:
	N=2
		N^20   = 1048576
		1024^N = 1048576
	N=3
		N^13   = 1594323
		100^N  = 1000000
	N=4
		N^10   = 1048576
		32^N   = 1048576
	N=5
		N^9    = 1953125
		16^N   = 1048576
	N=10
		N^6    = 1000000
		4^N    = 1048576
	N=1000
		N^2    = 1000000
		1^N    = 1000
		
	
	If N is quantity of nodes, D is quantity of floating points in the first set, E is quantity of floating points in the second set, then...
	
	D^N would be bayesian, if D=2.
	N^D would be neural node, if D=1, and N^D would be unoptimized neural net, if D=2.
	
	2^N * 2^1 * N^1 would sum bayesian weights.
	
	
	
	N leads to N^2, which leads to N^3...
	N also leads to 2^N, but 2^N does not lead to 3^N.
	
	
	Nodes are not for storing whole sounds. They are for 1 audio sample at a time.
	It would be ok to limit a node to 65536 childs, and a set of floating point numbers to the same.
	
	
	A normal bayesian node with 1 child has 2^2 weights.
	
	A 16-way bayesian node with 1 child has 16^2 weights, and is very similar to a fully connected neural network of 16 nodes.
	
	A 16-way bayesian node with 2 child has 16^3 weights,
	and is very similar to a more complex type of neural network of 16 nodes where edges look 2 nodes ahead instead of 1 ahead.
	
	A 5-way bayesian node with 1 child has 5^2 weights, and is very similar to a fully connected neural network of 5 nodes.
	
	A normal bayesian node with 6 childs has 2^7 weights.
	
	Because all types of bayesian can be simulated using various depths of neural networks,
	maybe only 2-way bayesian nodes should be allowed.
	
	Maybe each node should have 2 sets of nodes, size X and Y,
	and include 1 set of floating points, size X^Y. For normal bayes node, X is [false,true] and size 2.
	
	----all this is getting confusing. Unify these designs...---
	
	Example, a 4-way bayesian node with 4 childs has 4^4 = 256 weights.
	It could be represented as 2 sets of 4 childs each, and 256 numbers.
	
	Simplified, a N^N node where N is 4, that represents all possible sequences of 4 nodes allowing duplicates.
	
	If this...
	Maybe each node should have 2 sets of nodes, size X and Y,
	and include 1 set of floating points, size X^Y. For normal bayes node, X is [false,true] and size 2.
	...then what does it mean when [false,true] is replaced in some nodes with [dog,cat,tree]?
	...Does it mean to connect nodes between the 2 sets? That would be a good algorithm if some of the
	nodes in each set were networks instead of nodes, and only parts of those networks were connected.

</simpleNode>